home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / MacPerl 5.0.3 / MacPerl Source ƒ / Perl5 / scope.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-15  |  13.6 KB  |  687 lines  |  [TEXT/MPS ]
  1. /*    scope.c
  2.  *
  3.  *    Copyright (c) 1991-1994, Larry Wall
  4.  *
  5.  *    You may distribute under the terms of either the GNU General Public
  6.  *    License or the Artistic License, as specified in the README file.
  7.  *
  8.  */
  9.  
  10. /*
  11.  * "For the fashion of Minas Tirith was such that it was built on seven
  12.  * levels..."
  13.  */
  14.  
  15. #include "EXTERN.h"
  16. #include "perl.h"
  17.  
  18. SV**
  19. stack_grow(sp, p, n)
  20. SV** sp;
  21. SV** p;
  22. int n;
  23. {
  24.     stack_sp = sp;
  25.     av_extend(stack, (p - stack_base) + (n) + 128);
  26. #ifdef NOTDEF
  27.     stack_sp = AvARRAY(stack) + (sp - stack_base);
  28.     stack_base = AvARRAY(stack);
  29.     stack_max = stack_base + AvMAX(stack) - 1;
  30. #endif
  31.     return stack_sp;
  32. }
  33.  
  34. I32
  35. cxinc()
  36. {
  37.     cxstack_max = cxstack_max * 3 / 2;
  38.     Renew(cxstack, cxstack_max, CONTEXT);
  39.     return cxstack_ix + 1;
  40. }
  41.  
  42. void
  43. push_return(retop)
  44. OP *retop;
  45. {
  46.     if (retstack_ix == retstack_max) {
  47.     retstack_max = retstack_max * 3 / 2;
  48.     Renew(retstack, retstack_max, OP*);
  49.     }
  50.     retstack[retstack_ix++] = retop;
  51. }
  52.  
  53. OP *
  54. pop_return()
  55. {
  56.     if (retstack_ix > 0)
  57.     return retstack[--retstack_ix];
  58.     else
  59.     return Nullop;
  60. }
  61.  
  62. void
  63. push_scope()
  64. {
  65.     if (scopestack_ix == scopestack_max) {
  66.     scopestack_max = scopestack_max * 3 / 2;
  67.     Renew(scopestack, scopestack_max, I32);
  68.     }
  69.     scopestack[scopestack_ix++] = savestack_ix;
  70.  
  71. }
  72.  
  73. void
  74. pop_scope()
  75. {
  76.     I32 oldsave = scopestack[--scopestack_ix];
  77.     LEAVE_SCOPE(oldsave);
  78. }
  79.  
  80. void
  81. markstack_grow()
  82. {
  83.     I32 oldmax = markstack_max - markstack;
  84.     I32 newmax = oldmax * 3 / 2;
  85.  
  86.     Renew(markstack, newmax, I32);
  87.     markstack_ptr = markstack + oldmax;
  88.     markstack_max = markstack + newmax;
  89. }
  90.  
  91. void
  92. savestack_grow()
  93. {
  94.     savestack_max = savestack_max * 3 / 2;
  95.     Renew(savestack, savestack_max, ANY);
  96. }
  97.  
  98. void
  99. free_tmps()
  100. {
  101.     /* XXX should tmps_floor live in cxstack? */
  102.     I32 myfloor = tmps_floor;
  103.     while (tmps_ix > myfloor) {      /* clean up after last statement */
  104.     SV* sv = tmps_stack[tmps_ix];
  105.     tmps_stack[tmps_ix--] = Nullsv;
  106.     if (sv) {
  107. #ifdef DEBUGGING
  108.         SvTEMP_off(sv);
  109. #endif
  110.         SvREFCNT_dec(sv);        /* note, can modify tmps_ix!!! */
  111.     }
  112.     }
  113. }
  114.  
  115. SV *
  116. save_scalar(gv)
  117. GV *gv;
  118. {
  119.     register SV *sv;
  120.     SV *osv = GvSV(gv);
  121.  
  122.     SSCHECK(3);
  123.     SSPUSHPTR(gv);
  124.     SSPUSHPTR(osv);
  125.     SSPUSHINT(SAVEt_SV);
  126.  
  127.     sv = GvSV(gv) = NEWSV(0,0);
  128.     if (SvTYPE(osv) >= SVt_PVMG && SvMAGIC(osv) && SvTYPE(osv) != SVt_PVGV) {
  129.     sv_upgrade(sv, SvTYPE(osv));
  130.     if (SvGMAGICAL(osv)) {
  131.         mg_get(osv);
  132.         SvFLAGS(osv) |= (SvFLAGS(osv) &
  133.         (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
  134.     }
  135.     SvMAGIC(sv) = SvMAGIC(osv);
  136.     SvFLAGS(sv) |= SvMAGICAL(osv);
  137.     localizing = TRUE;
  138.     SvSETMAGIC(sv);
  139.     localizing = FALSE;
  140.     }
  141.     return sv;
  142. }
  143.  
  144. #ifdef INLINED_ELSEWHERE
  145. void
  146. save_gp(gv)
  147. GV *gv;
  148. {
  149.     register GP *gp;
  150.     GP *ogp = GvGP(gv);
  151.  
  152.     SSCHECK(3);
  153.     SSPUSHPTR(gv);
  154.     SSPUSHPTR(ogp);
  155.     SSPUSHINT(SAVEt_GP);
  156.  
  157.     Newz(602,gp, 1, GP);
  158.     GvGP(gv) = gp;
  159.     GvREFCNT(gv) = 1;
  160.     GvSV(gv) = NEWSV(72,0);
  161.     GvLINE(gv) = curcop->cop_line;
  162.     GvEGV(gv) = gv;
  163. }
  164. #endif
  165.  
  166. SV*
  167. save_svref(sptr)
  168. SV **sptr;
  169. {
  170.     register SV *sv;
  171.     SV *osv = *sptr;
  172.  
  173.     SSCHECK(3);
  174.     SSPUSHPTR(*sptr);
  175.     SSPUSHPTR(sptr);
  176.     SSPUSHINT(SAVEt_SVREF);
  177.  
  178.     sv = *sptr = NEWSV(0,0);
  179.     if (SvTYPE(osv) >= SVt_PVMG && SvMAGIC(osv) && SvTYPE(osv) != SVt_PVGV) {
  180.     sv_upgrade(sv, SvTYPE(osv));
  181.     if (SvGMAGICAL(osv)) {
  182.         mg_get(osv);
  183.         SvFLAGS(osv) |= (SvFLAGS(osv) &
  184.         (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
  185.     }
  186.     SvMAGIC(sv) = SvMAGIC(osv);
  187.     SvFLAGS(sv) |= SvMAGICAL(osv);
  188.     localizing = TRUE;
  189.     SvSETMAGIC(sv);
  190.     localizing = FALSE;
  191.     }
  192.     return sv;
  193. }
  194.  
  195. AV *
  196. save_ary(gv)
  197. GV *gv;
  198. {
  199.     SSCHECK(3);
  200.     SSPUSHPTR(gv);
  201.     SSPUSHPTR(GvAVn(gv));
  202.     SSPUSHINT(SAVEt_AV);
  203.  
  204.     GvAV(gv) = Null(AV*);
  205.     return GvAVn(gv);
  206. }
  207.  
  208. HV *
  209. save_hash(gv)
  210. GV *gv;
  211. {
  212.     SSCHECK(3);
  213.     SSPUSHPTR(gv);
  214.     SSPUSHPTR(GvHVn(gv));
  215.     SSPUSHINT(SAVEt_HV);
  216.  
  217.     GvHV(gv) = Null(HV*);
  218.     return GvHVn(gv);
  219. }
  220.  
  221. void
  222. save_item(item)
  223. register SV *item;
  224. {
  225.     register SV *sv;
  226.  
  227.     SSCHECK(3);
  228.     SSPUSHPTR(item);        /* remember the pointer */
  229.     sv = NEWSV(0,0);
  230.     sv_setsv(sv,item);
  231.     SSPUSHPTR(sv);        /* remember the value */
  232.     SSPUSHINT(SAVEt_ITEM);
  233. }
  234.  
  235. void
  236. save_int(intp)
  237. int *intp;
  238. {
  239.     SSCHECK(3);
  240.     SSPUSHINT(*intp);
  241.     SSPUSHPTR(intp);
  242.     SSPUSHINT(SAVEt_INT);
  243. }
  244.  
  245. void
  246. save_long(longp)
  247. long *longp;
  248. {
  249.     SSCHECK(3);
  250.     SSPUSHLONG(*longp);
  251.     SSPUSHPTR(longp);
  252.     SSPUSHINT(SAVEt_LONG);
  253. }
  254.  
  255. void
  256. save_I32(intp)
  257. I32 *intp;
  258. {
  259.     SSCHECK(3);
  260.     SSPUSHINT(*intp);
  261.     SSPUSHPTR(intp);
  262.     SSPUSHINT(SAVEt_I32);
  263. }
  264.  
  265. void
  266. save_iv(ivp)
  267. IV *ivp;
  268. {
  269.     SSCHECK(3);
  270.     SSPUSHINT(*ivp);
  271.     SSPUSHPTR(ivp);
  272.     SSPUSHINT(SAVEt_IV);
  273. }
  274.  
  275. /* Cannot use save_sptr() to store a char* since the SV** cast will
  276.  * force word-alignment and we'll miss the pointer.
  277.  */
  278. void
  279. save_pptr(pptr)
  280. char **pptr;
  281. {
  282.     SSCHECK(3);
  283.     SSPUSHPTR(*pptr);
  284.     SSPUSHPTR(pptr);
  285.     SSPUSHINT(SAVEt_PPTR);
  286. }
  287.  
  288. void
  289. save_sptr(sptr)
  290. SV **sptr;
  291. {
  292.     SSCHECK(3);
  293.     SSPUSHPTR(*sptr);
  294.     SSPUSHPTR(sptr);
  295.     SSPUSHINT(SAVEt_SPTR);
  296. }
  297.  
  298. void
  299. save_nogv(gv)
  300. GV *gv;
  301. {
  302.     SSCHECK(2);
  303.     SSPUSHPTR(gv);
  304.     SSPUSHINT(SAVEt_NSTAB);
  305. }
  306.  
  307. void
  308. save_hptr(hptr)
  309. HV **hptr;
  310. {
  311.     SSCHECK(3);
  312.     SSPUSHPTR(*hptr);
  313.     SSPUSHPTR(hptr);
  314.     SSPUSHINT(SAVEt_HPTR);
  315. }
  316.  
  317. void
  318. save_aptr(aptr)
  319. AV **aptr;
  320. {
  321.     SSCHECK(3);
  322.     SSPUSHPTR(*aptr);
  323.     SSPUSHPTR(aptr);
  324.     SSPUSHINT(SAVEt_APTR);
  325. }
  326.  
  327. void
  328. save_freesv(sv)
  329. SV *sv;
  330. {
  331.     SSCHECK(2);
  332.     SSPUSHPTR(sv);
  333.     SSPUSHINT(SAVEt_FREESV);
  334. }
  335.  
  336. void
  337. save_freeop(op)
  338. OP *op;
  339. {
  340.     SSCHECK(2);
  341.     SSPUSHPTR(op);
  342.     SSPUSHINT(SAVEt_FREEOP);
  343. }
  344.  
  345. void
  346. save_freepv(pv)
  347. char *pv;
  348. {
  349.     SSCHECK(2);
  350.     SSPUSHPTR(pv);
  351.     SSPUSHINT(SAVEt_FREEPV);
  352. }
  353.  
  354. void
  355. save_clearsv(svp)
  356. SV** svp;
  357. {
  358.     SSCHECK(2);
  359.     SSPUSHPTR(svp);
  360.     SSPUSHINT(SAVEt_CLEARSV);
  361. }
  362.  
  363. void
  364. save_delete(hv,key,klen)
  365. HV *hv;
  366. char *key;
  367. I32 klen;
  368. {
  369.     SSCHECK(4);
  370.     SSPUSHINT(klen);
  371.     SSPUSHPTR(key);
  372.     SSPUSHPTR(hv);
  373.     SSPUSHINT(SAVEt_DELETE);
  374. }
  375.  
  376. void
  377. save_list(sarg,maxsarg)
  378. register SV **sarg;
  379. I32 maxsarg;
  380. {
  381.     register SV *sv;
  382.     register I32 i;
  383.  
  384.     SSCHECK(3 * maxsarg);
  385.     for (i = 1; i <= maxsarg; i++) {
  386.     SSPUSHPTR(sarg[i]);        /* remember the pointer */
  387.     sv = NEWSV(0,0);
  388.     sv_setsv(sv,sarg[i]);
  389.     SSPUSHPTR(sv);            /* remember the value */
  390.     SSPUSHINT(SAVEt_ITEM);
  391.     }
  392. }
  393.  
  394. void
  395. save_destructor(f,p)
  396. void (*f) _((void*));
  397. void* p;
  398. {
  399.     SSCHECK(3);
  400.     SSPUSHDPTR(f);
  401.     SSPUSHPTR(p);
  402.     SSPUSHINT(SAVEt_DESTRUCTOR);
  403. }
  404.  
  405. void
  406. leave_scope(base)
  407. I32 base;
  408. {
  409.     register SV *sv;
  410.     register SV *value;
  411.     register GV *gv;
  412.     register AV *av;
  413.     register HV *hv;
  414.     register void* ptr;
  415.  
  416.     if (base < -1)
  417.     croak("panic: corrupt saved stack index");
  418.     while (savestack_ix > base) {
  419.     switch (SSPOPINT) {
  420.     case SAVEt_ITEM:            /* normal string */
  421.         value = (SV*)SSPOPPTR;
  422.         sv = (SV*)SSPOPPTR;
  423.         sv_replace(sv,value);
  424.         localizing = TRUE;
  425.         SvSETMAGIC(sv);
  426.         localizing = FALSE;
  427.         break;
  428.         case SAVEt_SV:                /* scalar reference */
  429.         value = (SV*)SSPOPPTR;
  430.         gv = (GV*)SSPOPPTR;
  431.         sv = GvSV(gv);
  432.         if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv) && SvTYPE(sv) != SVt_PVGV){
  433.         (void)SvUPGRADE(value, SvTYPE(sv));
  434.         SvMAGIC(value) = SvMAGIC(sv);
  435.         SvFLAGS(value) |= SvMAGICAL(sv);
  436.         SvMAGICAL_off(sv);
  437.         SvMAGIC(sv) = 0;
  438.         }
  439.             SvREFCNT_dec(sv);
  440.             GvSV(gv) = value;
  441.         localizing = TRUE;
  442.         SvSETMAGIC(value);
  443.         localizing = FALSE;
  444.             break;
  445.         case SAVEt_SVREF:            /* scalar reference */
  446.         ptr = SSPOPPTR;
  447.         sv = *(SV**)ptr;
  448.         value = (SV*)SSPOPPTR;
  449.         if (SvTYPE(sv) >= SVt_PVMG && SvTYPE(sv) != SVt_PVGV) {
  450.         (void)SvUPGRADE(value, SvTYPE(sv));
  451.         SvMAGIC(value) = SvMAGIC(sv);
  452.         SvFLAGS(value) |= SvMAGICAL(sv);
  453.         SvMAGICAL_off(sv);
  454.         SvMAGIC(sv) = 0;
  455.         }
  456.             SvREFCNT_dec(sv);
  457.         *(SV**)ptr = value;
  458.         localizing = TRUE;
  459.         SvSETMAGIC(value);
  460.         localizing = FALSE;
  461.             break;
  462.         case SAVEt_AV:                /* array reference */
  463.         av = (AV*)SSPOPPTR;
  464.         gv = (GV*)SSPOPPTR;
  465.             SvREFCNT_dec(GvAV(gv));
  466.             GvAV(gv) = av;
  467.             break;
  468.         case SAVEt_HV:                /* hash reference */
  469.         hv = (HV*)SSPOPPTR;
  470.         gv = (GV*)SSPOPPTR;
  471.             SvREFCNT_dec(GvHV(gv));
  472.             GvHV(gv) = hv;
  473.             break;
  474.     case SAVEt_INT:                /* int reference */
  475.         ptr = SSPOPPTR;
  476.         *(int*)ptr = (int)SSPOPINT;
  477.         break;
  478.     case SAVEt_LONG:            /* long reference */
  479.         ptr = SSPOPPTR;
  480.         *(long*)ptr = (long)SSPOPLONG;
  481.         break;
  482.     case SAVEt_I32:                /* I32 reference */
  483.         ptr = SSPOPPTR;
  484.         *(I32*)ptr = (I32)SSPOPINT;
  485.         break;
  486.     case SAVEt_IV:                /* IV reference */
  487.         ptr = SSPOPPTR;
  488.         *(IV*)ptr = (IV)SSPOPIV;
  489.         break;
  490.     case SAVEt_SPTR:            /* SV* reference */
  491.         ptr = SSPOPPTR;
  492.         *(SV**)ptr = (SV*)SSPOPPTR;
  493.         break;
  494.     case SAVEt_PPTR:            /* char* reference */
  495.         ptr = SSPOPPTR;
  496.         *(char**)ptr = (char*)SSPOPPTR;
  497.         break;
  498.     case SAVEt_HPTR:            /* HV* reference */
  499.         ptr = SSPOPPTR;
  500.         *(HV**)ptr = (HV*)SSPOPPTR;
  501.         break;
  502.     case SAVEt_APTR:            /* AV* reference */
  503.         ptr = SSPOPPTR;
  504.         *(AV**)ptr = (AV*)SSPOPPTR;
  505.         break;
  506.     case SAVEt_NSTAB:
  507.         gv = (GV*)SSPOPPTR;
  508.         (void)sv_clear(gv);
  509.         break;
  510.         case SAVEt_GP:                /* scalar reference */
  511.         ptr = SSPOPPTR;
  512.         gv = (GV*)SSPOPPTR;
  513.             gp_free(gv);
  514.             GvGP(gv) = (GP*)ptr;
  515.             break;
  516.     case SAVEt_FREESV:
  517.         ptr = SSPOPPTR;
  518.         SvREFCNT_dec((SV*)ptr);
  519.         break;
  520.     case SAVEt_FREEOP:
  521.         ptr = SSPOPPTR;
  522.         curpad = AvARRAY(comppad);
  523.         op_free((OP*)ptr);
  524.         break;
  525.     case SAVEt_FREEPV:
  526.         ptr = SSPOPPTR;
  527.         Safefree((char*)ptr);
  528.         break;
  529.     case SAVEt_CLEARSV:
  530.         ptr = SSPOPPTR;
  531.         sv = *(SV**)ptr;
  532.         if (SvREFCNT(sv) <= 1) { /* Can clear pad variable in place. */
  533.         if (SvTHINKFIRST(sv)) {
  534.             if (SvREADONLY(sv))
  535.             croak("panic: leave_scope clearsv");
  536.             if (SvROK(sv))
  537.             sv_unref(sv);
  538.         }
  539.         if (SvMAGICAL(sv))
  540.             mg_free(sv);
  541.  
  542.         switch (SvTYPE(sv)) {
  543.         case SVt_NULL:
  544.             break;
  545.         case SVt_PVAV:
  546.             av_clear((AV*)sv);
  547.             break;
  548.         case SVt_PVHV:
  549.             hv_clear((HV*)sv);
  550.             break;
  551.         case SVt_PVCV:
  552.             sub_generation++;
  553.             cv_undef((CV*)sv);
  554.             break;
  555.         default:
  556.             if (SvPOK(sv) && SvLEN(sv))
  557.             (void)SvOOK_off(sv);
  558.             (void)SvOK_off(sv);
  559.             break;
  560.         }
  561.         }
  562.         else {    /* Someone has a claim on this, so abandon it. */
  563.         SvREFCNT_dec(sv);    /* Cast current value to the winds. */
  564.         switch (SvTYPE(sv)) {    /* Console ourselves with a new value */
  565.         case SVt_PVAV:    *(SV**)ptr = (SV*)newAV();    break;
  566.         case SVt_PVHV:    *(SV**)ptr = (SV*)newHV();    break;
  567.         default:    *(SV**)ptr = NEWSV(0,0);    break;
  568.         }
  569.         }
  570.         break;
  571.     case SAVEt_DELETE:
  572.         ptr = SSPOPPTR;
  573.         hv = (HV*)ptr;
  574.         ptr = SSPOPPTR;
  575.         hv_delete(hv, (char*)ptr, (U32)SSPOPINT);
  576.         break;
  577.     case SAVEt_DESTRUCTOR:
  578.         ptr = SSPOPPTR;
  579.         (*SSPOPDPTR)(ptr);
  580.         break;
  581.     case SAVEt_REGCONTEXT:
  582.         savestack_ix -= SSPOPINT;    /* regexp must have croaked */
  583.         break;
  584.     default:
  585.         croak("panic: leave_scope inconsistency");
  586.     }
  587.     }
  588. }
  589.  
  590. #ifdef DEBUGGING
  591.  
  592. #ifdef macintosh
  593. #undef stderr
  594. #define stderr gPerlDbg
  595. #endif
  596.  
  597. void
  598. cx_dump(cx)
  599. CONTEXT* cx;
  600. {
  601.     fprintf(stderr, "CX %d = %s\n", cx - cxstack, block_type[cx->cx_type]);
  602.     if (cx->cx_type != CXt_SUBST) {
  603.     fprintf(stderr, "BLK_OLDSP = %ld\n", (long)cx->blk_oldsp);
  604.     fprintf(stderr, "BLK_OLDCOP = 0x%lx\n", (long)cx->blk_oldcop);
  605.     fprintf(stderr, "BLK_OLDMARKSP = %ld\n", (long)cx->blk_oldmarksp);
  606.     fprintf(stderr, "BLK_OLDSCOPESP = %ld\n", (long)cx->blk_oldscopesp);
  607.     fprintf(stderr, "BLK_OLDRETSP = %ld\n", (long)cx->blk_oldretsp);
  608.     fprintf(stderr, "BLK_OLDPM = 0x%lx\n", (long)cx->blk_oldpm);
  609.     fprintf(stderr, "BLK_GIMME = %s\n", cx->blk_gimme ? "LIST" : "SCALAR");
  610.     }
  611.     switch (cx->cx_type) {
  612.     case CXt_NULL:
  613.     case CXt_BLOCK:
  614.     break;
  615.     case CXt_SUB:
  616.     fprintf(stderr, "BLK_SUB.CV = 0x%lx\n",
  617.         (long)cx->blk_sub.cv);
  618.     fprintf(stderr, "BLK_SUB.GV = 0x%lx\n",
  619.         (long)cx->blk_sub.gv);
  620.     fprintf(stderr, "BLK_SUB.DFOUTGV = 0x%lx\n",
  621.         (long)cx->blk_sub.dfoutgv);
  622.     fprintf(stderr, "BLK_SUB.OLDDEPTH = %ld\n",
  623.         (long)cx->blk_sub.olddepth);
  624.     fprintf(stderr, "BLK_SUB.HASARGS = %d\n",
  625.         (int)cx->blk_sub.hasargs);
  626.     break;
  627.     case CXt_EVAL:
  628.     fprintf(stderr, "BLK_EVAL.OLD_IN_EVAL = %ld\n",
  629.         (long)cx->blk_eval.old_in_eval);
  630.     fprintf(stderr, "BLK_EVAL.OLD_OP_TYPE = %s\n",
  631.         op_name[cx->blk_eval.old_op_type]);
  632.     fprintf(stderr, "BLK_EVAL.OLD_NAME = %s\n",
  633.         cx->blk_eval.old_name);
  634.     fprintf(stderr, "BLK_EVAL.OLD_EVAL_ROOT = 0x%lx\n",
  635.         (long)cx->blk_eval.old_eval_root);
  636.     break;
  637.  
  638.     case CXt_LOOP:
  639.     fprintf(stderr, "BLK_LOOP.LABEL = %s\n",
  640.         cx->blk_loop.label);
  641.     fprintf(stderr, "BLK_LOOP.RESETSP = %ld\n",
  642.         (long)cx->blk_loop.resetsp);
  643.     fprintf(stderr, "BLK_LOOP.REDO_OP = 0x%lx\n",
  644.         (long)cx->blk_loop.redo_op);
  645.     fprintf(stderr, "BLK_LOOP.NEXT_OP = 0x%lx\n",
  646.         (long)cx->blk_loop.next_op);
  647.     fprintf(stderr, "BLK_LOOP.LAST_OP = 0x%lx\n",
  648.         (long)cx->blk_loop.last_op);
  649.     fprintf(stderr, "BLK_LOOP.ITERIX = %ld\n",
  650.         (long)cx->blk_loop.iterix);
  651.     fprintf(stderr, "BLK_LOOP.ITERARY = 0x%lx\n",
  652.         (long)cx->blk_loop.iterary);
  653.     fprintf(stderr, "BLK_LOOP.ITERVAR = 0x%lx\n",
  654.         (long)cx->blk_loop.itervar);
  655.     if (cx->blk_loop.itervar)
  656.         fprintf(stderr, "BLK_LOOP.ITERSAVE = 0x%lx\n",
  657.         (long)cx->blk_loop.itersave);
  658.     break;
  659.  
  660.     case CXt_SUBST:
  661.     fprintf(stderr, "SB_ITERS = %ld\n",
  662.         (long)cx->sb_iters);
  663.     fprintf(stderr, "SB_MAXITERS = %ld\n",
  664.         (long)cx->sb_maxiters);
  665.     fprintf(stderr, "SB_SAFEBASE = %ld\n",
  666.         (long)cx->sb_safebase);
  667.     fprintf(stderr, "SB_ONCE = %ld\n",
  668.         (long)cx->sb_once);
  669.     fprintf(stderr, "SB_ORIG = %s\n",
  670.         cx->sb_orig);
  671.     fprintf(stderr, "SB_DSTR = 0x%lx\n",
  672.         (long)cx->sb_dstr);
  673.     fprintf(stderr, "SB_TARG = 0x%lx\n",
  674.         (long)cx->sb_targ);
  675.     fprintf(stderr, "SB_S = 0x%lx\n",
  676.         (long)cx->sb_s);
  677.     fprintf(stderr, "SB_M = 0x%lx\n",
  678.         (long)cx->sb_m);
  679.     fprintf(stderr, "SB_STREND = 0x%lx\n",
  680.         (long)cx->sb_strend);
  681.     fprintf(stderr, "SB_SUBBASE = 0x%lx\n",
  682.         (long)cx->sb_subbase);
  683.     break;
  684.     }
  685. }
  686. #endif
  687.